Introduction to Number Data Type

In JavaScript, the Number data type represents both integers and floating-point numbers. Numbers in JavaScript are 64-bit double-precision values, meaning they follow the IEEE 754 standard for representing both whole and fractional numbers.

Integer Example:   let num1 = 42;

Floating-point Example:   let num2 = 3.14;

JavaScript automatically converts between integer and floating-point representations as necessary. Other forms of numbers like hexadecimal (e.g., 0xFF), exponential notation (e.g., 1e6), and octal (ES6 feature) are also supported.

Number Methods

JavaScript provides several methods and properties to manipulate and work with numbers. Let’s explore the most commonly used methods.

Number() Constructor

The Number() function converts any value into a number.

let num1 = Number('42');     // 42
    let num2 = Number('3.14');   // 3.14
    let num3 = Number(true);     // 1
    let num4 = Number(false);    // 0

toString()

The toString() method converts a number to a string. It can also accept an optional radix argument to return the string representation of the number in a different base (binary, octal, hexadecimal).

let num = 42;
    
    console.log(num.toString());        // '42'
    console.log(num.toString(2));       // '101010' (binary)
    console.log(num.toString(16));      // '2a' (hexadecimal)

toFixed()

The toFixed() method formats a number to a fixed number of decimal places. It returns the result as a string.

let num = 3.14159;
    
    console.log(num.toFixed(2));  // '3.14'
    console.log(num.toFixed(0));  // '3'

toPrecision()

The toPrecision() method formats a number to a specified precision (total number of digits). It returns the result as a string.

let num = 123.456;
    
    console.log(num.toPrecision(4));   // '123.5'
    console.log(num.toPrecision(2));   // '1.2e+2'

parseInt()

The parseInt() function parses a string and returns an integer of the specified radix (base). If no radix is provided, it assumes base 10 for typical usage but defaults to base 16 for strings starting with "0x" (hexadecimal).

console.log(parseInt('42'));        // 42 (decimal)
    console.log(parseInt('0xF', 16));   // 15 (hexadecimal)

parseFloat()

The parseFloat() function parses a string and returns a floating-point number. It reads until it encounters a non-numeric character.

console.log(parseFloat('3.14'));     // 3.14
    console.log(parseFloat('3.14abc'));  // 3.14

isNaN()

The isNaN() function checks whether a value is NaN (Not-a-Number). It returns true if the value is NaN, and false otherwise. It is useful for checking invalid number conversions.

console.log(isNaN('Hello'));    // true
    console.log(isNaN(42));         // false

isFinite()

The isFinite() method checks whether a value is a finite number. It returns true for any number except Infinity, -Infinity, or NaN.

console.log(isFinite(100));     // true
    console.log(isFinite(Infinity)); // false
    console.log(isFinite(NaN));     // false

Number.isInteger()

The Number.isInteger() method checks if the value is an integer.

console.log(Number.isInteger(42));   // true
    console.log(Number.isInteger(3.14)); // false

Number.isNaN()

The Number.isNaN() method is more reliable than the global isNaN() function for checking whether a value is NaN, because it does not coerce the argument to a number first.

console.log(Number.isNaN(NaN));       // true
    console.log(Number.isNaN('Hello'));   // false

Number.MAX_VALUE and Number.MIN_VALUE

Number.MAX_VALUE: Represents the largest positive number that can be represented in JavaScript.

Number.MIN_VALUE: Represents the smallest positive number (closest to zero) that can be represented.

console.log(Number.MAX_VALUE);  // 1.7976931348623157e+308
    console.log(Number.MIN_VALUE);  // 5e-324

Number.POSITIVE_INFINITY and Number.NEGATIVE_INFINITY

Number.POSITIVE_INFINITY: Represents positive infinity in JavaScript.

Number.NEGATIVE_INFINITY: Represents negative infinity.

console.log(Number.POSITIVE_INFINITY); // Infinity
    console.log(Number.NEGATIVE_INFINITY); // -Infinity

Number.isSafeInteger()

The Number.isSafeInteger() method checks whether the value is a safe integer. A safe integer is an integer that can be represented exactly in JavaScript (between -(2^53 - 1) and 2^53 - 1).

console.log(Number.isSafeInteger(42));            // true
    console.log(Number.isSafeInteger(9007199254740992)); // false

Special Number Values

JavaScript recognizes certain special values in addition to regular numbers:

NaN: "Not-a-Number," which occurs when a mathematical operation fails.

Infinity: A value that represents infinity in mathematical operations.

-Infinity: A value that represents negative infinity.

console.log(1 / 0);      // Infinity
    console.log(-1 / 0);     // -Infinity
    console.log(0 / 0);      // NaN

Automatic Type Conversion

JavaScript automatically converts numbers to strings when necessary. This is known as type coercion, and it happens, for example, when concatenating a number and a string.

let num = 10;
    let str = 'The number is ' + num;
    
    console.log(str);  // 'The number is 10'

Summary

• Numbers in JavaScript are represented as 64-bit double-precision floating-point numbers.
• JavaScript provides methods like Number(), toString(), toFixed(), toPrecision(), parseInt(), parseFloat(), and others to work with numbers.
• Special values include NaN, Infinity, and -Infinity.
• JavaScript performs automatic type conversion (coercion) when necessary.